home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb.new / sprite / kgdb / sun4_kgdb_remote.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-30  |  38.4 KB  |  1,535 lines
  1. /* 
  2.  * kgdb_remote_sun4.c --
  3.  *
  4.  *    
  5.  *
  6.  * Copyright 1991 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that this copyright
  10.  * notice appears in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: /sprite/lib/forms/RCS/proto.c,v 1.5 91/02/09 13:24:44 ouster Exp $ SPRITE (Berkeley)";
  18.  
  19. #include <stdio.h>
  20. #include <sprite.h>
  21. #include <signal.h>
  22. #include <sys/types.h>
  23. #include <sys/file.h>
  24. #include <sys/wait.h>
  25. #include <errno.h>
  26. #include "kernel/machTypes.h"
  27.  
  28. #include "defs.h"
  29. #include "param.h"
  30. #include "frame.h"
  31. #include "inferior.h"
  32. #include "value.h"
  33. #include "expression.h"
  34. #include "target.h"
  35. #include "wait.h"
  36. #include "terminal.h"
  37. #include "sprite.h"
  38. #include "kernel/sun4.md/vmSunConst.h"
  39. #include "kernel/sun4.md/machConst.h"
  40. #include "kernel/sun4.md/dbg.h"
  41.  
  42. extern struct value *call_function_by_hand();
  43. extern void start_remote ();
  44.  
  45. extern struct target_ops remote_ops;    /* Forward decl */
  46.  
  47.  
  48. /*
  49.  * Hostname of attached remote hosts.  Error otherwise.
  50.  */
  51.  
  52. char *hostName;
  53.  
  54. /*
  55.  * Useful macros
  56.  * ERROR_NO_ATTACHED_HOST - Remote an error and abort if no host is
  57.  *                currently attached.
  58.  * MARK_DISCONNECTED - Mark a host a disconnected and free up state.
  59.  */
  60.  
  61. #define ERROR_NO_ATTACHED_HOST \
  62.     if (!hostName) error("No machine attached.");
  63.  
  64. #define MARK_DISCONNECTED  {     \
  65.     initialized = 0;          \
  66.     inferior_pid = 0;        \
  67.     hostName = (char *) 0;     \
  68.     free(dataCache);      \
  69.     free(cacheInfo);      \
  70.     }
  71.  
  72.  
  73. static    int    initialized = 0; /* Set to true when remote connection is
  74.                   * initialized. */
  75.  
  76. /*
  77.  * Table mapping kernel exceptions into Unix signals.  
  78.  */
  79.  
  80. struct sig_mapping_struct {
  81.     char     *sig_name;    /* Print string for signal. */
  82.     int     dbgSig;     /* Boolean - A signal used by the debugger. */
  83.     int     unixSignal;     /* Unix signal equalient. */
  84. } sig_mapping[] =  {
  85. /* 0 */ { "Reset Trap", 0, SIGQUIT },
  86. /* 1 */ { "Instruction Fault", 0, SIGSEGV },
  87. /* 2 */ { "Illegal Instruction Fault", 0, SIGILL },
  88. /* 3 */ { "Privilege Instruction Fault", 0, SIGILL },
  89. /* 4 */ { "FPU Disabled Fault", 0, SIGFPE },
  90. /* 5 */ { "Window Overflow Fault", 0, SIGBUS },
  91. /* 6 */ { "Window Underflow Fault", 0, SIGBUS },
  92. /* 7 */ { "Memory Address Fault", 0, SIGSEGV },
  93. /* 8 */ { "FPU Exception Fault", 0, SIGFPE },
  94. /* 9 */ { "Data Fault",  0, SIGSEGV },
  95. /* 10 */ { "Tag Overflow Trap", 0, SIGSEGV },
  96. /* 11 */ { "Unknown Trap 11",  0, SIGSEGV },
  97. /* 12 */ { "Unknown Trap 12",  0, SIGSEGV },
  98. /* 13 */ { "Unknown Trap 13",  0, SIGSEGV },
  99. /* 14 */ { "Unknown Trap 14",  0, SIGSEGV },
  100. /* 15 */ { "Unknown Trap 15",  0, SIGSEGV },
  101. /* 16 */ { "Interrupt Trap",  0, SIGINT },
  102. /* 17 */ { "Level 1 Interrupt", 0, SIGINT },
  103. /* 18 */ { "Level 2 Interrupt", 0, SIGINT },
  104. /* 19 */ { "Level 3 Interrupt", 0, SIGINT },
  105. /* 20 */ { "Level 4 Interrupt", 0, SIGINT },
  106. /* 21 */ { "Level 5 Interrupt", 0, SIGINT },
  107. /* 22 */ { "Level 6 Interrupt", 0, SIGINT },
  108. /* 23 */ { "Level 7 Interrupt", 0, SIGINT },
  109. /* 24 */ { "Level 8 Interrupt", 0, SIGINT },
  110. /* 25 */ { "Level 9 Interrupt", 0, SIGINT },
  111. /* 26 */ { "Level 10 Interrupt", 0, SIGINT },
  112. /* 27 */ { "Level 11 Interrupt", 0, SIGINT },
  113. /* 28 */ { "Level 12 Interrupt", 0, SIGINT },
  114. /* 29 */ { "Level 13 Interrupt", 0, SIGINT },
  115. /* 30 */ { "Level 14 Interrupt", 0, SIGINT },
  116. /* 31 */ { "Level 15 Interrupt", 0, SIGINT },
  117. /* 32 */ { "Breakpoint Trap",  1, SIGTRAP },
  118. /* 33 */ { "Unknown Trap",  0, SIGSEGV },
  119. /* 34 */ { "UNKNOWN EXCEPTION", 0, SIGSEGV },
  120. };
  121.  
  122. #define    NUM_SIG_MAPS    (sizeof(sig_mapping)/sizeof(sig_mapping[0]))
  123.  
  124.  
  125.  
  126. #define    PBUFSIZ    1024
  127.  
  128. /* Maximum number of bytes to read/write at once.  The value here
  129.    is chosen to fill up a packet (the headers account for the 32).  */
  130. #define MAXBUFBYTES ((PBUFSIZ-32)/2)
  131.  
  132.  
  133. /*
  134.  *----------------------------------------------------------------------
  135.  *
  136.  * Regnum_to_index --
  137.  *
  138.  *    Function mapping a gdb register number into an index.
  139.  *
  140.  * Results:
  141.  *    Index to Mach_State structure when treated as an array on ints.
  142.  *
  143.  * Side effects:
  144.  *    None.
  145.  *
  146.  *----------------------------------------------------------------------
  147.  */
  148. static int 
  149. Regnum_to_index(r) 
  150.     int    r;
  151. { 
  152. #define    O(f)    ((int)&(((Mach_RegState *) 0)->f)/sizeof(int))
  153.   if (r < 8) return O(globals[r]);
  154.   if (r < 16) return  O(ins[r-8]);
  155.   if (r < 32) return (r - 16);
  156.   if (r == Y_REGNUM) return O(y);
  157.   if (r == PS_REGNUM) return O(curPsr);
  158.   if (r == PC_REGNUM) return O(pc);
  159.   if (r == NPC_REGNUM) return O(nextPc);
  160.   return -1;
  161. #undef O
  162. };
  163. static int lastPid = -1;    /* Process ID of process being examined. -1
  164.                  * means process causing trap. */
  165.  
  166. /*
  167.  * The following variables are sued when using the core memory interface
  168.  * rather than active ethernet debugging.
  169.  */
  170. static int remoteCoreChan = -1;    /* Open file descriptor of core file. -1 
  171.                  * means no file open. */
  172. static char *remoteCoreFile;    /* Malloced name of core file. */
  173. static int remoteOffset;    /* Offset used to convert addresses to 
  174.                  * offsets into core file. */
  175. static StopInfo    remoteStopInfo;    /* Current Dbg_StopInfo from core file. */
  176. static Dbg_DumpBounds remoteBounds;  /* Dump bounds from core file. */
  177.  
  178. /*
  179.  * IN_CORE_FILE - Returns TRUE if address is in the corefile.
  180.  */
  181. #define    IN_CORE_FILE(addr) ((addr) >= (CORE_ADDR) remoteBounds.kernelCodeStart\
  182.       && ((addr) < (CORE_ADDR) remoteBounds.fileCacheStart + \
  183.                           remoteBounds.fileCacheSize))
  184.  
  185. /*
  186.  *----------------------------------------------------------------------
  187.  *
  188.  * remote_core_file_command --
  189.  *
  190.  *    kgdb.sun4 core_file command.
  191.  *
  192.  * Results:
  193.  *    None.
  194.  *
  195.  * Side effects:
  196.  *    None.
  197.  *
  198.  *----------------------------------------------------------------------
  199.  */
  200.  
  201. void
  202. remote_core_file_command (filename, from_tty)
  203.      char *filename;
  204.      int from_tty;
  205. {
  206.   /* Discard all vestiges of any previous core file
  207.      and mark data and stack spaces as empty.  */
  208.  
  209.   if (remoteCoreFile)
  210.     free (remoteCoreFile);
  211.   remoteCoreFile = 0;
  212.  
  213.   if (remoteCoreChan >= 0)
  214.     close (remoteCoreChan);
  215.   remoteCoreChan = -1;
  216.   if (filename == 0) {
  217.     printf ("Corefile cleared.\n");
  218.     return;
  219.   }
  220.  
  221.   filename = tilde_expand (filename);
  222.   make_cleanup (free, filename);
  223.  
  224.   remoteCoreChan = open (filename, O_RDONLY, 0);
  225.   if (remoteCoreChan < 0)
  226.     perror_with_name (filename);
  227.  
  228.   {
  229.     /*
  230.      * Read the StopInfo and bounds and start the debugging session.
  231.      */
  232.     int val;
  233.     val = myread (remoteCoreChan, &remoteStopInfo, sizeof remoteStopInfo);
  234.     if (val < 0)
  235.       perror_with_name (filename);
  236.     val = myread (remoteCoreChan, &remoteBounds, sizeof remoteBounds);
  237.     if (val < 0)
  238.       perror_with_name (filename);
  239.     remote_debugging = 1;
  240.     remoteOffset = remoteBounds.kernelCodeStart - sizeof(remoteStopInfo) -
  241.             sizeof(remoteBounds);
  242.     start_remote();
  243.   }
  244. }
  245.  
  246. /* Open a connection to a remote debugger.
  247.    NAME is the filename used for communication.  */
  248.  
  249. void
  250. remote_open (name, from_tty)
  251.      char *name;
  252.      int from_tty;
  253. {
  254.   if (remoteCoreChan >= 0) {
  255.       error("Can't attach a machine when using a corefile\n");
  256.       return;
  257.   }
  258.  
  259.   if (name == 0)
  260.     error (
  261. "To open a remote debug connection, you need to specify what host\n\
  262. machine is attached to the remote system (e.g. allspice).");
  263.  
  264.   hostName = savestring(name,strlen(name));
  265.   if (from_tty)
  266.     printf ("Remote debugging using %s\n", name);
  267.   push_target (&remote_ops);    /* Switch to using remote target now */
  268. }
  269.  
  270. char *
  271. remote_version()
  272. {
  273.   static char    version[1024];
  274.  
  275.   ERROR_NO_ATTACHED_HOST;
  276.   Kdbx_Trace(DBG_GET_VERSION_STRING, 0, version, 1024);
  277.   return version;
  278. }
  279.  
  280.  
  281.  
  282. /* Tell the remote machine to resume.  */
  283.  
  284. int     step_addr, step_addr_contents[2];
  285.  
  286. int
  287. remote_resume (step, signal)
  288.      int step, signal;
  289. {
  290.  
  291.   ERROR_NO_ATTACHED_HOST;
  292.   step_addr = -2;
  293.   if (step) {
  294.          static char break_insn[] = BREAKPOINT;
  295.          step_addr = read_register(NPC_REGNUM);
  296.          if ((remote_read_bytes(step_addr,step_addr_contents,8) != 0) ||
  297.          (remote_write_bytes(step_addr,break_insn, 4) != 0) ||
  298.          (remote_write_bytes(step_addr+4,break_insn, 4) != 0)) {
  299.          error("Can't set single step breakpoint at 0x%x\n", step_addr);
  300.       }
  301.  
  302.   }
  303.   if (Kdbx_Trace( DBG_CONTINUE, 0, 0, sizeof(int)) < 0) {
  304.         error("error trying to continue process\n");
  305.   }
  306.  
  307. }
  308.  
  309. /* Wait until the remote machine stops, then return,
  310.    storing status in STATUS just as `wait' would.  */
  311.  
  312. int
  313. remote_wait (status)
  314.      WAITTYPE *status;
  315. {
  316.     StopInfo    stopInfo;
  317.     int        trap;
  318.     int    text_size;
  319.     extern CORE_ADDR text_start, text_end;
  320.     if (remoteCoreChan >= 0) {
  321.     /*
  322.      * Debugging using core file, just set text_{start, end} and
  323.      * returned stopped signal.
  324.      */
  325.     status->w_status = 0;
  326.     status->w_stopval = WSTOPPED;
  327.     trap = DBG_CVT_MACH_TRAP(remoteStopInfo.trapType);
  328.     status->w_stopsig = sig_mapping[trap].unixSignal;
  329.     if ((lastPid == -1) && !sig_mapping[trap].dbgSig) { 
  330.         printf("Kernel returns with signal (%d) %s\n",
  331.             remoteStopInfo.trapType,
  332.             sig_mapping[trap].sig_name);
  333.     }
  334.     text_start = remoteBounds.kernelCodeStart;
  335.     text_end = remoteBounds.kernelCodeStart + remoteBounds.kernelCodeSize;
  336.     return status->w_stopsig;
  337.     }
  338.     ERROR_NO_ATTACHED_HOST;
  339.  
  340.     if (Kdbx_Trace(DBG_GET_STOP_INFO, (char *) 0, (char *)&stopInfo,
  341.                sizeof(stopInfo)) != 0) {
  342.     error("Can't get stop info\n");
  343.     }
  344.  
  345.     if (stopInfo.regs.pc == step_addr ||
  346.     stopInfo.regs.pc == step_addr+4) {
  347.          if (remote_write_bytes(step_addr,step_addr_contents, 8) != 0) 
  348.          error("Can't restore single step address\n");
  349.     }
  350.     status->w_status = 0;
  351.     status->w_stopval = WSTOPPED;
  352.  
  353.     trap = DBG_CVT_MACH_TRAP(stopInfo.trapType);
  354.     status->w_stopsig = sig_mapping[trap].unixSignal;
  355.     if ((lastPid != -1) && !sig_mapping[trap].dbgSig) { 
  356.     printf("Kernel returns with signal (%d) %s\n",stopInfo.trapType,
  357.         sig_mapping[trap].sig_name);
  358.     }
  359.  
  360.     text_size = text_end - text_start;
  361.     text_size &= ~(8*1024-1);
  362.     text_start = stopInfo.codeStart - 8*1024;
  363.     text_end = text_start+text_size;
  364.     return status->w_stopsig;
  365. }
  366.  
  367. /* Read the remote registers into the block REGS.  */
  368. #define FIRST_LOCAL_REGNUM    16
  369. void
  370. remote_fetch_registers (regs)
  371.      char *regs;
  372. {
  373.   StopInfo    stopInfo;
  374.   if (remoteCoreChan >= 0) {
  375.  
  376.       bcopy(remoteStopInfo.regs.globals,regs,4*8);
  377.       bcopy(remoteStopInfo.regs.ins,regs+4*8,4*8);
  378.       ((int *)regs)[Y_REGNUM] = remoteStopInfo.regs.y; 
  379.       ((int *)regs)[PS_REGNUM] = remoteStopInfo.regs.curPsr; 
  380.       ((int *)regs)[PC_REGNUM] = remoteStopInfo.regs.pc; 
  381.       ((int *)regs)[NPC_REGNUM] = remoteStopInfo.regs.nextPc; 
  382.       remote_read_bytes(remoteStopInfo.regs.ins[6], 
  383.             ((int *) regs) + FIRST_LOCAL_REGNUM,4*16);
  384.       return;
  385.   }
  386.   ERROR_NO_ATTACHED_HOST;
  387.   Kdbx_Trace(DBG_GET_STOP_INFO, (char *) 0, (char *)&stopInfo,
  388.                sizeof(stopInfo));
  389.   bcopy(stopInfo.regs.globals,regs,4*8);
  390.   bcopy(stopInfo.regs.ins,regs+4*8,4*8);
  391.   ((int *)regs)[Y_REGNUM] = stopInfo.regs.y; 
  392.   ((int *)regs)[PS_REGNUM] = stopInfo.regs.curPsr; 
  393.   ((int *)regs)[PC_REGNUM] = stopInfo.regs.pc; 
  394.   ((int *)regs)[NPC_REGNUM] = stopInfo.regs.nextPc; 
  395.   remote_read_bytes(stopInfo.regs.ins[6], 
  396.         ((int *) regs) + FIRST_LOCAL_REGNUM,4*16);
  397.  
  398. }
  399.  
  400.  
  401. int
  402. remote_attach(pid)
  403.     int    pid;
  404. {
  405.     int    status;
  406.     struct expression *expr;
  407.     register struct cleanup *old_chain;
  408.     register value val;
  409.     int    machRegStateAddr;
  410.     Proc_ControlBlock    *procPtr;
  411.     Mach_RegState machRegState;
  412.     char    exp[128];
  413.  
  414.     if (remoteCoreChan >= 0) {
  415.     if (pid != lastPid) {
  416.       /*
  417.        * Switching to a new process. 
  418.        */
  419.       if (pid == -1) {
  420.           /*
  421.            * Process -1 is the trap process. Whose stop info is 
  422.            * in the beginning of the corefile.
  423.            */
  424.           if (lseek(remoteCoreChan, 0, L_SET) < 0) {
  425.           error("lseek corefile");
  426.           return 0;
  427.            }
  428.           if (myread(remoteCoreChan, &remoteStopInfo, 
  429.             sizeof(remoteStopInfo)) < 0) {
  430.           error("read corefile");
  431.           return 0;
  432.           }
  433.           lastPid = pid;
  434.           start_remote();
  435.           return 1;
  436.       }
  437.       /*
  438.        * Lookup the switch regs of the specified process.
  439.        * They are in proc_PCBTable[pidSlot]->machStatePtr->switchRegs.
  440.        */
  441.       sprintf(exp,"proc_PCBTable[%d]", pid & 0xff);
  442.       expr = parse_c_expression (exp);
  443.       old_chain = make_cleanup (free_current_contents, &expr);
  444.  
  445.       val = evaluate_expression (expr);
  446.       do_cleanups (old_chain);
  447.       if ((value_as_long(val) == NIL) || (value_as_long(val) == 0)) {
  448.           error("Pid 0x%x does not have a control block\n", pid);
  449.       }
  450.       sprintf(exp,"proc_PCBTable[%d]->machStatePtr->switchRegs", pid & 0xff);
  451.       expr = parse_c_expression (exp);
  452.       old_chain = make_cleanup (free_current_contents, &expr);
  453.       val = evaluate_expression (expr);
  454.       do_cleanups (old_chain);
  455.       machRegStateAddr = value_as_long(val);
  456.       if (remote_read_bytes(machRegStateAddr, &machRegState, 
  457.             sizeof(Mach_RegState)) != 0) {
  458.         error("Can't read  regs from address 0x%x\n", machRegStateAddr);
  459.       }
  460.       remoteStopInfo.regs = machRegState;
  461.       /*
  462.        * The PC that is stored for a switch registers from on the
  463.        * sun4 is bogus.  We set the PC to be inside Mach_ContextSwitch.
  464.        */
  465.       strcpy(exp,"&Mach_ContextSwitch");
  466.       expr = parse_c_expression (exp);
  467.       old_chain = make_cleanup (free_current_contents, &expr);
  468.       val = evaluate_expression (expr);
  469.       do_cleanups (old_chain);
  470.       remoteStopInfo.regs.pc = value_as_long(val)+16;
  471.       remoteStopInfo.regs.nextPc = remoteStopInfo.regs.pc+4;
  472.       lastPid = pid;
  473.     }
  474.     start_remote();
  475.     return 1;
  476.     }
  477.     ERROR_NO_ATTACHED_HOST;
  478.     if (pid != lastPid) {
  479.     Kdbx_Trace(DBG_SET_PID, &pid, 0,sizeof(int));
  480.     lastPid = pid;
  481.     }
  482.     start_remote();
  483.     return 1;
  484. }
  485.  
  486. /* remote_detach()
  487.    takes a program previously attached to and detaches it.
  488.    We better not have left any breakpoints
  489.    in the program or it'll die when it hits one.
  490.    Close the open connection to the remote debugger.
  491.    Use this when you want to detach and do something else
  492.    with your gdb.  */
  493.  
  494. static void
  495. remote_detach(args, from_tty)
  496.      char *args;
  497.      int from_tty;
  498. {
  499.   int cur_pc;
  500.  
  501.   ERROR_NO_ATTACHED_HOST;
  502.   cur_pc = read_pc();
  503.   if (args) 
  504.       Kdbx_Trace(DBG_DETACH, &cur_pc, 0, sizeof(int));
  505.   remote_clean_up();
  506.   pop_target ();
  507.   if (from_tty)
  508.     printf ("Ending remote debugging.\n");
  509. }
  510.  
  511.  
  512.  
  513. /* Read a word from remote address ADDR and return it.
  514.    This goes through the data cache.  */
  515.  
  516. int
  517. remote_fetch_word (addr)
  518.      CORE_ADDR addr;
  519. {
  520.  
  521.   int buffer;
  522.   extern CORE_ADDR text_start, text_end;
  523.  
  524.   if (remoteCoreChan >= 0) {
  525.       if (IN_CORE_FILE(addr)) {
  526.       if (lseek(remoteCoreChan, addr - remoteOffset, L_SET) < 0) {
  527.           perror("lseek corefile");
  528.           errno = EIO;
  529.           return 0;
  530.        }
  531.       if (myread(remoteCoreChan, &buffer, sizeof(buffer)) < 0) {
  532.           perror("read corefile");
  533.           errno = EIO;
  534.           return 0;
  535.       }
  536.       } else {
  537.       /* fprintf(stderr, "Address 0x%x out of range\n", addr); */
  538.       errno = EIO;
  539.       return 0;
  540.       }
  541.       return buffer;
  542.   }
  543.  
  544.   ERROR_NO_ATTACHED_HOST;
  545.   if (addr >= text_start && addr < text_end)
  546.     {
  547.      if (Kdbx_Trace(DBG_INST_READ, addr, &buffer, sizeof(int)) != 0) {
  548.         errno = EIO;
  549.         return 0;
  550.      }
  551.      return buffer;
  552.     }
  553.   if (Kdbx_Trace(DBG_DATA_READ, addr, &buffer, sizeof(int)) != 0) {
  554.     errno = EIO;
  555.     return 0;
  556.   }
  557.   return buffer;
  558. }
  559.  
  560. /* Write a word WORD into remote address ADDR.
  561.    This goes through the data cache.  */
  562.  
  563. void
  564. remote_store_word (addr, word)
  565.      CORE_ADDR addr;
  566.      int word;
  567. {
  568.   extern CORE_ADDR text_start, text_end;
  569.   ERROR_NO_ATTACHED_HOST;
  570.   if (addr >= text_start && addr < text_end)
  571.     {
  572.       if (Kdbx_Trace(DBG_INST_WRITE, &word, addr, sizeof(word))!= 0) {
  573.         errno = EIO;
  574.         }
  575.         return;
  576.     }
  577.   if ( Kdbx_Trace(DBG_DATA_WRITE,  &word, addr, sizeof(word)) != 0) {
  578.      errno = EIO;
  579.   }
  580.   return;
  581. }
  582.  
  583. /* Write memory data directly to the remote machine.
  584.    This does not inform the data cache; the data cache uses this.
  585.    MEMADDR is the address in the remote memory space.
  586.    MYADDR is the address of the buffer in our space.
  587.    LEN is the number of bytes.  */
  588.  
  589. int
  590. remote_write_bytes (memaddr, myaddr, len)
  591.      CORE_ADDR memaddr;
  592.      char *myaddr;
  593.      int len;
  594. {
  595.   extern CORE_ADDR text_start, text_end;
  596.   ERROR_NO_ATTACHED_HOST;
  597.   if (memaddr >= text_start && memaddr < text_end)
  598.     {
  599.       return Kdbx_Trace(DBG_INST_WRITE, myaddr, memaddr, len);
  600.     }
  601.   return Kdbx_Trace(DBG_DATA_WRITE,  myaddr, memaddr, len);
  602. }
  603.  
  604. /* Read memory data directly from the remote machine.
  605.    This does not use the data cache; the data cache uses this.
  606.    MEMADDR is the address in the remote memory space.
  607.    MYADDR is the address of the buffer in our space.
  608.    LEN is the number of bytes.  */
  609.  
  610. int
  611. remote_read_bytes (memaddr, myaddr, len)
  612.      CORE_ADDR memaddr;
  613.      char *myaddr;
  614.      int len;
  615. {
  616.     int err;
  617.  
  618.   if (remoteCoreChan >= 0) {
  619.       if (IN_CORE_FILE(memaddr)) {
  620.       if (lseek(remoteCoreChan, memaddr - remoteOffset, L_SET) < 0) {
  621.           err = errno;
  622.           perror("lseek corefile");
  623.           return err;
  624.        }
  625.       if (myread(remoteCoreChan,myaddr, len) != len) {
  626.           err = errno;
  627.           perror("read corefile");
  628.           return (err > 0) ? err : 1;
  629.       }
  630.     } else {
  631.       /* fprintf(stderr, "Address 0x%x out of range\n", memaddr); */
  632.       return EIO;
  633.     }
  634.     return 0;
  635.   }
  636.   ERROR_NO_ATTACHED_HOST;
  637.   return Kdbx_Trace(DBG_DATA_READ, memaddr, myaddr, len);
  638. }
  639.  
  640. /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
  641.    at debugger address MYADDR.  Returns errno value.  */
  642. int
  643. remote_read_inferior_memory(memaddr, myaddr, len)
  644.      CORE_ADDR memaddr;
  645.      char *myaddr;
  646.      int len;
  647. {
  648.   int xfersize, err;
  649.   while (len > 0)
  650.     {
  651.       if (len > MAXBUFBYTES)
  652.     xfersize = MAXBUFBYTES;
  653.       else
  654.     xfersize = len;
  655.  
  656.       err = remote_read_bytes (memaddr, myaddr, xfersize);
  657.       if (err != 0) 
  658.       return err;
  659.       memaddr += xfersize;
  660.       myaddr  += xfersize;
  661.       len     -= xfersize;
  662.     }
  663.   return 0; /* no error */
  664. }
  665.  
  666. /* Copy LEN bytes of data from debugger memory at MYADDR
  667.    to inferior's memory at MEMADDR.  Returns errno value.  */
  668. int
  669. remote_write_inferior_memory (memaddr, myaddr, len)
  670.      CORE_ADDR memaddr;
  671.      char *myaddr;
  672.      int len;
  673. {
  674.   int xfersize;
  675.   int err;
  676.   while (len > 0)
  677.     {
  678.       if (len > MAXBUFBYTES)
  679.     xfersize = MAXBUFBYTES;
  680.       else
  681.     xfersize = len;
  682.  
  683.       err = remote_write_bytes(memaddr, myaddr, xfersize);
  684.       if (err != 0) {
  685.     return err;
  686.       }
  687.  
  688.       memaddr += xfersize;
  689.       myaddr  += xfersize;
  690.       len     -= xfersize;
  691.     }
  692.   return 0; /* no error */
  693. }
  694.  
  695. /* Store the remote registers from the contents of the block REGS.  */
  696.  
  697. void
  698. remote_store_registers (regs,regno)
  699.      char *regs;
  700.      int    regno;
  701. {
  702.     int    i;
  703.  
  704.   ERROR_NO_ATTACHED_HOST;
  705.     if (regno < 0) { 
  706.     remote_write_bytes(((int *) regs)[SP_REGNUM], 
  707.                 ((int *) regs) + FIRST_LOCAL_REGNUM,4*16);
  708.     for (i = 0; i < 16; i++) {
  709.         Kdbx_Trace(DBG_WRITE_REG, &(((int *)regs)[i]),
  710.                     Regnum_to_index(i),sizeof(int));
  711.     }    
  712.        Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+Y_REGNUM,
  713.             Regnum_to_index(Y_REGNUM),sizeof(int));
  714.        Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+PC_REGNUM,
  715.             Regnum_to_index(PC_REGNUM),sizeof(int));
  716.        Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+NPC_REGNUM,
  717.             Regnum_to_index(NPC_REGNUM),sizeof(int));
  718.        Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+PS_REGNUM,
  719.             Regnum_to_index(PS_REGNUM),sizeof(int));
  720.  
  721.     } else {
  722.        int    ind = Regnum_to_index(regno);
  723.        if (ind >= 0) 
  724.        Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+regno,ind,sizeof(int));
  725.        else
  726.         remote_write_bytes(((int *) regs)[SP_REGNUM], 
  727.             ((int *) regs) + regno,4);
  728.     }
  729. }
  730.  
  731. /* 
  732.  * Call a remote function.
  733.  */
  734. call_remote_function(funaddr,nargs,numBytes,argBuffer)
  735.     CORE_ADDR funaddr;
  736.     int        nargs;
  737.     int        numBytes;
  738.     char    *argBuffer;
  739. {
  740.   int    returnValue;
  741.   ERROR_NO_ATTACHED_HOST;
  742.   Kdbx_Trace(DBG_BEGIN_CALL, (char *)0, (char *)0, 0);  
  743.   returnValue = Kdbx_Trace(DBG_CALL_FUNCTION,argBuffer,funaddr,numBytes);
  744.   Kdbx_Trace(DBG_END_CALL, (char *)0, (char *)0, 0);       
  745.   return returnValue;
  746. }
  747.  
  748. void
  749. remote_reboot (args)
  750.      char *args;
  751. {
  752.  
  753.   ERROR_NO_ATTACHED_HOST;
  754.   if (!args)
  755.     args = "";
  756.  
  757.   Kdbx_Trace(DBG_REBOOT, args, NULL, strlen(args));
  758. }
  759.  
  760.  
  761. #include <sys/types.h>
  762. #include <sys/socket.h>
  763. #include <sys/time.h>
  764. #include <netinet/in.h>
  765. #include <netdb.h>
  766. #include <sgtty.h>
  767.  
  768. /*
  769.  * Direct mapped cache of data and code.   The cache is flushed after every
  770.  * step and continue by incrementing the version number.  Flushing code
  771.  * isn't necessary but since kdbx already has an internal code cache it
  772.  * doesn't hurt and makes life easier.
  773.  */
  774. static    int    cacheBlockSize = -1;
  775. static    int    cacheBlockShift = -1;
  776. static    int    cacheSize = 128 * 1024;
  777. #define    CACHE_BLOCK_MASK     (cacheSize / cacheBlockSize - 1)
  778. #define    CACHE_BLOCK_OFFSET_MASK    (cacheBlockSize - 1)
  779. #define    NUM_CACHE_BLOCKS    (cacheSize >> cacheBlockShift)
  780. #define    CACHE_OFFSET_MASK    (cacheSize - 1)
  781. #define    GET_CACHE_BLOCK(address) (((unsigned int) address) >> cacheBlockShift)
  782. /*
  783.  * The data cache is just an array of characters.
  784.  */
  785. static    char    *dataCache;
  786. /*
  787.  * There is information about kept about each cache block.
  788.  */
  789. typedef    struct {
  790.     int        version;    /* Version number of this cache block. */
  791.     char    *realAddr;    /* Actual address of data stored in the block.*/
  792. } CacheInfo;
  793. static CacheInfo    *cacheInfo;
  794. static int    currentVersion = 1;
  795.  
  796. /*
  797.  * Stuff for the serial port.
  798.  */
  799. static    int    kernChannel = 0;
  800.  
  801.  
  802. /*
  803.  * Message buffers.
  804.  */
  805. static Dbg_Msg    msg;
  806. static int    msgSize;
  807. #define    REPLY_BUFFER_SIZE    16384
  808. static    char    replyBuffer[REPLY_BUFFER_SIZE];
  809. static    char    requestBuffer[DBG_MAX_REQUEST_SIZE];
  810. static    int    msgNum = 0;
  811.  
  812. static void    RecvReply();
  813.  
  814. static    struct sockaddr_in    remote;
  815. static    int            kdbxTimeout = 1;
  816. static    int            netSocket;
  817.  
  818.  
  819. /*
  820.  *----------------------------------------------------------------------
  821.  *
  822.  * CreateSocket --
  823.  *
  824.  *    Creates a UDP socket connected to the Sprite host's kernel 
  825.  *    debugger port.
  826.  *
  827.  * Results:
  828.  *    The stream ID of the socket.
  829.  *
  830.  * Side effects:
  831.  *    None.
  832.  *
  833.  *----------------------------------------------------------------------
  834.  */
  835. static int
  836. CreateSocket(spriteHostName)
  837.     char    *spriteHostName;
  838. {
  839.     int            socketID;
  840.     struct hostent     *hostPtr;
  841.  
  842.     hostPtr = gethostbyname(spriteHostName);
  843.     if (hostPtr == (struct hostent *) NULL) {
  844.     error("CreateSocket: unknown host %s\n", spriteHostName);
  845.     }
  846.     if (hostPtr->h_addrtype != AF_INET) {
  847.     error("CreateSocket: bad address type for host %s\n", 
  848.         spriteHostName);
  849.     }
  850.  
  851.     socketID = socket(AF_INET, SOCK_DGRAM, 0);
  852.     if (socketID < 0) {
  853.     perror_with_name("CreateSocket: socket");
  854.     }
  855.  
  856.     bzero((Address)&remote, sizeof(remote));
  857.     bcopy(hostPtr->h_addr, (Address)&remote.sin_addr, hostPtr->h_length);
  858.     remote.sin_port = htons(DBG_UDP_PORT);
  859.     remote.sin_family = AF_INET;
  860.  
  861.     if (connect(socketID, (struct sockaddr *) &remote, sizeof(remote)) < 0) {
  862.     perror_with_name("CreateSocket: connect");
  863.     }
  864.  
  865.     return(socketID);
  866. }
  867.  
  868.  
  869. /*
  870.  * ----------------------------------------------------------------------------
  871.  *
  872.  *  StartDebugger --
  873.  *
  874.  *     Start off a new conversation with the debugger.
  875.  *
  876.  * Results:
  877.  *     None.
  878.  *
  879.  * Side effects:
  880.  *     Setup r network socket.
  881.  * ----------------------------------------------------------------------------
  882.  */
  883. static void
  884. StartDebugger()
  885. {
  886.         char    *host = hostName;
  887.     hostName = (char *) 0;
  888.     netSocket = CreateSocket(host);
  889.     hostName = host;
  890. }
  891.  
  892.  
  893. /*
  894.  * ----------------------------------------------------------------------------
  895.  *
  896.  *  SendRequest --
  897.  *
  898.  *     Send a request message to the kernel.
  899.  *
  900.  * Results:
  901.  *     None.
  902.  *
  903.  * Side effects:
  904.  *     None.
  905.  * ----------------------------------------------------------------------------
  906.  */
  907. static void
  908. SendRequest(numBytes, newRequest)
  909.     int        numBytes;
  910.     Boolean    newRequest;
  911. {
  912.      {
  913.     Dbg_Opcode    opcode;
  914.  
  915.     msgSize = numBytes;
  916.     if (newRequest) {
  917.         msgNum++;
  918.     }
  919.     *(int *)requestBuffer = msgNum;
  920.     bcopy(&msg, requestBuffer + 4, numBytes);
  921.     if (write(netSocket, requestBuffer, numBytes + 4) < numBytes + 4) {
  922.          MARK_DISCONNECTED;
  923.         perror_with_name("SendRequest: Couldn't write to the kernel socket\n");
  924.         return;
  925.     }
  926.     if (newRequest) {
  927.         opcode = (Dbg_Opcode) msg.opcode;
  928.         if (opcode == DBG_DETACH || opcode == DBG_CONTINUE ||
  929.         opcode == DBG_SINGLESTEP || opcode == DBG_DIVERT_SYSLOG || 
  930.         opcode == DBG_BEGIN_CALL || 
  931.         opcode == DBG_WRITE_REG || opcode == DBG_SET_PID) {
  932.         int    dummy;
  933.         /*
  934.          * Wait for explicit acknowledgments of these packets.
  935.          */
  936.         RecvReply(opcode, 4, &dummy, NULL, 1);
  937.         }
  938.     }
  939.     }
  940. }
  941.  
  942.  
  943. /*
  944.  * ----------------------------------------------------------------------------
  945.  *
  946.  *  RecvReply --
  947.  *
  948.  *     Receive a reply from the kernel.
  949.  *
  950.  * Results:
  951.  *     None.
  952.  *
  953.  * Side effects:
  954.  *     None.
  955.  * ----------------------------------------------------------------------------
  956.  */
  957. static void
  958. RecvReply(opcode, numBytes, destAddr, readStatusPtr, timeout)
  959.     Dbg_Opcode    opcode;
  960.     int        numBytes;
  961.     char    *destAddr;
  962.     int    *readStatusPtr;
  963.     int    timeout;
  964. {
  965.     int        status;
  966.     int     resendRequest = 0;
  967.  
  968.     if (numBytes + 8 > REPLY_BUFFER_SIZE) {
  969.     fprintf(stderr,"numBytes <%d> > REPLY_BUFFER_SIZE <%d>\n",
  970.             numBytes + 8, REPLY_BUFFER_SIZE);
  971.     abort();
  972.     }
  973.      {
  974.     int        readMask;
  975.     struct    timeval    interval;
  976.     int        bytesRead;
  977.  
  978.     interval.tv_sec = kdbxTimeout;
  979.     interval.tv_usec = 0;
  980.     do {
  981.         if (timeout) {
  982.         int    numTimeouts;
  983.  
  984.         numTimeouts = 0;
  985.         /*
  986.          * Loop timing out and sending packets until a new packet
  987.          * has arrived.
  988.          */
  989.         do {
  990.             if (!resendRequest) { 
  991.             readMask = 1 << netSocket;
  992.             status = select(32, &readMask, NULL, NULL, &interval);
  993.             } else {
  994.             status = 0;
  995.             resendRequest = 0;
  996.             }
  997.             if (status == 1) {
  998.             break;
  999.             } else if (status == -1) {
  1000.                 MARK_DISCONNECTED;
  1001.             perror_with_name("RecvReply: Couldn't select on socket.\n");
  1002.             } else if (status == 0) {
  1003.             SendRequest(msgSize, 0);
  1004.             numTimeouts++;
  1005.             if (numTimeouts % 10 == 0) {
  1006.                 fprintf(stderr, 
  1007.                     "Timing out and resending to host %s\n",
  1008.                     hostName);
  1009.                 fflush(stderr);
  1010.                 QUIT;
  1011.             }
  1012.             }
  1013.         } while (1);
  1014.         }
  1015.         if (opcode == DBG_DATA_READ || opcode == DBG_INST_READ ||
  1016.         opcode == DBG_GET_VERSION_STRING) {
  1017.         /*
  1018.          * Data and instruction reads return variable size packets.
  1019.          * The first two ints are message number and status.  If
  1020.          * the status is OK then the data follows.
  1021.          */
  1022.         immediate_quit++;
  1023.         bytesRead = read(netSocket, replyBuffer, numBytes + 8);
  1024.         immediate_quit--;
  1025.         if (bytesRead < 0) {
  1026.             MARK_DISCONNECTED;
  1027.             perror_with_name("RecvReply: Error reading socket.");
  1028.         }
  1029.         /*
  1030.          * Check message number before the size because this could
  1031.          * be an old packet.
  1032.          */
  1033.         if (*(int *)replyBuffer != msgNum) {
  1034.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1035.                 *(int *)replyBuffer, msgNum);
  1036.             fflush(stdout);
  1037.             resendRequest = 1;
  1038.             continue;
  1039.         }
  1040.         if (bytesRead == 8) {
  1041.             /*
  1042.              * Only 8 bytes so the read failed and there is no data.
  1043.              */
  1044.             *readStatusPtr = 0;
  1045.             return;
  1046.         }
  1047.             if (opcode == DBG_GET_VERSION_STRING) {
  1048.              strncpy(destAddr, (char *)(replyBuffer + 4),numBytes);
  1049.              return;
  1050.         }
  1051.         if (bytesRead != numBytes + 8) {
  1052.             printf("RecvReply: Short read (1): op=%d exp=%d read=%d",
  1053.                 opcode, numBytes + 4, bytesRead);
  1054.             continue;
  1055.         }
  1056.         *readStatusPtr = 1;
  1057.         bcopy(replyBuffer + 8, destAddr, numBytes);
  1058.         return;
  1059.         } else if (opcode == DBG_END_CALL) {
  1060.         int    length;
  1061.         /*
  1062.          * End call returns a variable size packet that contains
  1063.          * the result of the call. The format of the message is 
  1064.          * message number, length, data.
  1065.          */
  1066.         immediate_quit++;
  1067.         bytesRead = read(netSocket, replyBuffer, REPLY_BUFFER_SIZE);
  1068.         immediate_quit--;
  1069.         if (bytesRead < 0) {
  1070.             MARK_DISCONNECTED;
  1071.             perror_with_name("RecvReply: Error reading socket.");
  1072.         }
  1073.         /*
  1074.          * Check message number before the size because this could
  1075.          * be an old packet.
  1076.          */
  1077.         if (*(int *)replyBuffer != msgNum) {
  1078.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1079.                 *(int *)replyBuffer, msgNum);
  1080.             fflush(stdout);
  1081.             resendRequest = 1;
  1082.             continue;
  1083.         }
  1084.         length = *( int *)(replyBuffer + 4);
  1085.         if (bytesRead - 8 != length) {
  1086.             fprintf(stderr, "RecyReply: Short read for syslog data\n");
  1087.             fflush(stderr);
  1088.             length = bytesRead - 8;
  1089.         }
  1090.         if (length == 0) {
  1091.             /*
  1092.              * No data.
  1093.              */
  1094.             *readStatusPtr = 0;
  1095.             return;
  1096.         }
  1097.         /*
  1098.          * Dump out the buffer.
  1099.          */
  1100.         write(1, replyBuffer + 8, length);
  1101.         *readStatusPtr = 1;
  1102.         return;
  1103.         } else {
  1104.         /*
  1105.          * Normal request so just read in the message which includes
  1106.          * the message number.
  1107.          */
  1108.         immediate_quit++;
  1109.         bytesRead = read(netSocket, replyBuffer, numBytes + 4);
  1110.         immediate_quit--;
  1111.         if (bytesRead < 0) {
  1112.             MARK_DISCONNECTED;
  1113.             perror_with_name("RecvReply: Error reading socket (2).");
  1114.         }
  1115.         /*
  1116.          * Check message number before size because it could be
  1117.          * an old packet.
  1118.          */
  1119.         if (*(int *)replyBuffer != msgNum) {
  1120.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1121.                 *(int *)replyBuffer, msgNum);
  1122.             fflush(stdout);
  1123.             resendRequest = 1;
  1124.             continue;
  1125.         }
  1126.         if (bytesRead != numBytes + 4) {
  1127.             printf("RecvReply: Short read (2): op=%d exp=%d read=%d",
  1128.                 opcode, numBytes + 4, bytesRead);
  1129.         }
  1130.         if (*(int *)replyBuffer != msgNum) {
  1131.             continue;
  1132.         }
  1133.         bcopy(replyBuffer + 4, destAddr, numBytes);
  1134.         return;
  1135.         }
  1136.     } while (1);
  1137.     }
  1138. }
  1139.  
  1140.  
  1141. /*
  1142.  * ----------------------------------------------------------------------------
  1143.  *
  1144.  *  WaitForKernel --
  1145.  *
  1146.  *      Wait for the kernel to send us a message to indicate that it is waiting
  1147.  *    to be debugged.
  1148.  *
  1149.  * Results:
  1150.  *     None.
  1151.  *
  1152.  * Side effects:
  1153.  *     None.
  1154.  * ----------------------------------------------------------------------------
  1155.  */
  1156. static void
  1157. WaitForKernel()
  1158. {
  1159.     int    dummy;
  1160.  
  1161.     RecvReply(DBG_CONTINUE, 4, &dummy, NULL, 0);
  1162. }
  1163.  
  1164.  
  1165. /*
  1166.  * ----------------------------------------------------------------------------
  1167.  *
  1168.  * BlockInCache --
  1169.  *
  1170.  *     See if the given block at the given address is in the cache.
  1171.  *
  1172.  * Results:
  1173.  *     1 if found block in cache, 0 if didn't.
  1174.  *
  1175.  * Side effects:
  1176.  *     None.
  1177.  */
  1178. static int
  1179. BlockInCache(blockNum, addr)
  1180.     int        blockNum;
  1181.     char    *addr;
  1182. {
  1183.     blockNum = blockNum & CACHE_BLOCK_MASK;
  1184.     return((int) (cacheInfo[blockNum].version == currentVersion &&
  1185.        (unsigned int) cacheInfo[blockNum].realAddr == 
  1186.             ((unsigned int) (addr) & ~CACHE_BLOCK_OFFSET_MASK)));
  1187. }
  1188.  
  1189.  
  1190. /*
  1191.  * ----------------------------------------------------------------------------
  1192.  *
  1193.  * FetchBlock --
  1194.  *
  1195.  *     Fetch the given data block from the cache or the kernel if necessary.
  1196.  *
  1197.  * Results:
  1198.  *     1 if could fetch block into cache, 0 if couldn't.
  1199.  *
  1200.  * Side effects:
  1201.  *     Data cache modified.
  1202.  */
  1203. static int
  1204. FetchBlock(blockNum, srcAddr, opcode)
  1205.     int        blockNum;
  1206.     char    *srcAddr;
  1207.     Dbg_Opcode    opcode;
  1208. {
  1209.     int    successfulRead;
  1210.  
  1211.     blockNum = blockNum & CACHE_BLOCK_MASK;
  1212.     srcAddr = (char *) ((unsigned int) (srcAddr) & ~CACHE_BLOCK_OFFSET_MASK);
  1213.  
  1214.     if (BlockInCache(blockNum, srcAddr)) {
  1215.     return(1);
  1216.     }
  1217.     msg.opcode = opcode;
  1218.     msg.data.readMem.address = (int) srcAddr;
  1219.     msg.data.readMem.numBytes = cacheBlockSize;
  1220.     SendRequest(sizeof(msg.opcode) + sizeof(Dbg_ReadMem), 1);
  1221.     RecvReply(opcode, cacheBlockSize, 
  1222.         &dataCache[(unsigned int) (srcAddr) & CACHE_OFFSET_MASK],
  1223.         &successfulRead, 1);
  1224.     if (successfulRead) {
  1225.     cacheInfo[blockNum].version = currentVersion;
  1226.     cacheInfo[blockNum].realAddr = srcAddr;
  1227.     }
  1228.     return(successfulRead);
  1229. }
  1230.  
  1231.  
  1232.  
  1233. /*
  1234.  * ----------------------------------------------------------------------------
  1235.  *
  1236.  * Kdbx_Trace --
  1237.  *
  1238.  *     Write the trace command over to the kernel.  
  1239.  *
  1240.  * Results:
  1241.  *     None.
  1242.  *
  1243.  * Side effects:
  1244.  *     None.
  1245.  *
  1246.  * ----------------------------------------------------------------------------
  1247.  */
  1248. int 
  1249. Kdbx_Trace(opcode, srcAddr, destAddr, numBytes)
  1250.     Dbg_Opcode    opcode;        /* Which command */
  1251.     char    *srcAddr;    /* Where to read data from */
  1252.     char    *destAddr;    /* Where to write data to */
  1253.     int        numBytes;    /* The number of bytes to read or write */
  1254. {
  1255.     int            (*intrHandler)();
  1256.     int            i;
  1257.     int            retVal = 0;
  1258.  
  1259.     if (!initialized) {
  1260.     int    moreData;
  1261.     /*
  1262.      * Setup the cache and initiate a conversation with the other kernel.
  1263.      */
  1264.     if (cacheBlockSize == -1) {
  1265.          {
  1266.         cacheBlockSize = 256;
  1267.         cacheBlockShift = 8;
  1268.         }
  1269.     }
  1270.     dataCache = (char *) malloc(cacheSize);
  1271.     cacheInfo = (CacheInfo *) malloc(NUM_CACHE_BLOCKS * sizeof(CacheInfo));
  1272.     for (i = 0; i < NUM_CACHE_BLOCKS; i++) {
  1273.         cacheInfo[i].version = 0;
  1274.     }
  1275.     StartDebugger();
  1276.     /*
  1277.      * Dump the system log by faking a call command.
  1278.      */
  1279.     printf("Dumping system log ...\n");
  1280.     fflush(stdout);
  1281.     msg.opcode = (short)DBG_BEGIN_CALL;
  1282.     SendRequest(sizeof(msg.opcode), 1);
  1283.     msg.opcode = (short)DBG_END_CALL;
  1284.     do {
  1285.         SendRequest(sizeof(msg.opcode), 1);
  1286.         RecvReply(msg.opcode, 0, NULL, &moreData, 1);
  1287.     } while (moreData);
  1288.     initialized = 1;
  1289.     }
  1290.  
  1291.  
  1292.     if (opcode == DBG_DATA_READ || opcode == DBG_INST_READ) {
  1293.     int            firstBlock;
  1294.     int            lastBlock;
  1295.     unsigned    int    cacheOffset;
  1296.     int            toRead;
  1297.  
  1298.     /*
  1299.      * Read using the cache.
  1300.      */
  1301.     firstBlock = GET_CACHE_BLOCK(srcAddr); 
  1302.     lastBlock = GET_CACHE_BLOCK(srcAddr + numBytes - 1);
  1303.     for (i = firstBlock; i <= lastBlock; i++) {
  1304.         cacheOffset = ((unsigned int) srcAddr) & CACHE_OFFSET_MASK;
  1305.         if (i == lastBlock) {
  1306.         toRead = numBytes;
  1307.         } else if (i == firstBlock) {
  1308.         toRead = cacheBlockSize - 
  1309.                 (cacheOffset & CACHE_BLOCK_OFFSET_MASK);
  1310.         } else {
  1311.         toRead = cacheBlockSize;
  1312.         }
  1313.         if (!FetchBlock(i, srcAddr, opcode)) {
  1314.         return EIO;
  1315.         }
  1316.         bcopy(&dataCache[cacheOffset], destAddr, toRead);
  1317.         srcAddr += toRead;
  1318.         destAddr += toRead;
  1319.         numBytes -= toRead;
  1320.     }
  1321.     return(0);
  1322.     }
  1323.  
  1324.     if (opcode == DBG_DATA_WRITE || opcode == DBG_INST_WRITE) {
  1325.     int    firstBlock;
  1326.     int    lastBlock;
  1327.     int    cacheOffset;
  1328.     int    toWrite;
  1329.     char    *tSrcAddr;
  1330.     char    *tDestAddr;
  1331.     int    tNumBytes;
  1332.  
  1333.     /*
  1334.      * If the block that is being fetched is in the cache then write the
  1335.      * data there first before sending it over to the kernel.
  1336.      */
  1337.     tSrcAddr = srcAddr;
  1338.     tDestAddr = destAddr;
  1339.     tNumBytes = numBytes;
  1340.  
  1341.     firstBlock = GET_CACHE_BLOCK(destAddr); 
  1342.     lastBlock = GET_CACHE_BLOCK(destAddr + numBytes - 1);
  1343.     for (i = firstBlock; i <= lastBlock; i++) {
  1344.         cacheOffset = ((int) tDestAddr) & CACHE_OFFSET_MASK;
  1345.         if (i == lastBlock) {
  1346.         toWrite = tNumBytes;
  1347.         } else if (i == firstBlock) {
  1348.         toWrite = cacheBlockSize - 
  1349.                 (cacheOffset & CACHE_BLOCK_OFFSET_MASK);
  1350.         } else {
  1351.         toWrite = cacheBlockSize;
  1352.         }
  1353.         if (BlockInCache(i, tDestAddr)) {
  1354.         bcopy(tSrcAddr, &dataCache[cacheOffset], tNumBytes);
  1355.         }
  1356.         tSrcAddr += toWrite;
  1357.         tDestAddr += toWrite;
  1358.         tNumBytes -= toWrite;
  1359.     }
  1360.     }
  1361.  
  1362.     msg.opcode = (short) opcode;
  1363.  
  1364.     /*
  1365.      * Do the rest of the work for the desired operation.
  1366.      */
  1367.  
  1368.     switch (opcode) {
  1369.  
  1370.     /*
  1371.      * For these operations the desired data is read from the other
  1372.      * kernel and stored at destAddr.
  1373.      */
  1374.     case DBG_READ_ALL_REGS:
  1375.     case DBG_GET_STOP_INFO:
  1376.         SendRequest(sizeof(msg.opcode), 1);
  1377.         RecvReply(opcode, numBytes, destAddr, NULL, 1);
  1378.         break;
  1379.  
  1380.     /*
  1381.      * For this operation the desired data is read from srcAddr
  1382.      * and written to the other kernel.
  1383.      */
  1384.     case DBG_SET_PID:
  1385.         msg.data.pid = *(int *)srcAddr;
  1386.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pid), 1);
  1387.         break;
  1388.  
  1389.     /*
  1390.      * When writing a general purpose register first the address to write
  1391.      * that is stored in destAddr must be given to the other kernel.
  1392.      * Then the data itself which is stored at srcAddr can be written over.
  1393.      */
  1394.     case DBG_WRITE_REG:
  1395.         msg.data.writeReg.regNum = (int) destAddr;
  1396.         msg.data.writeReg.regVal = *(int *) srcAddr;
  1397.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_WriteReg), 1);
  1398.         break;
  1399.  
  1400.     /*
  1401.      * When writing to the kernels instruction or data space first the
  1402.      * address of where to write to (destAddr) and then the number of
  1403.      * bytes to write (numBytes) must be sent over.  Finally all of
  1404.      * the data is read from srcAddr and written over.
  1405.      */
  1406.  
  1407.     case DBG_INST_WRITE:
  1408.     case DBG_DATA_WRITE: {
  1409.         char    writeStatus;
  1410.  
  1411.         msg.data.writeMem.address = (int) destAddr;
  1412.         msg.data.writeMem.numBytes = numBytes;
  1413.         bcopy(srcAddr, msg.data.writeMem.buffer, numBytes);
  1414.         SendRequest(sizeof(msg.opcode) + 2 * sizeof(int) + numBytes, 1);
  1415.         RecvReply(opcode, 1, &writeStatus, NULL, 1);
  1416.         if (writeStatus == 0) {
  1417.         retVal = EIO;
  1418.         fprintf(stderr, "ERROR: invalid write address 0x%x\n",destAddr);
  1419.         } 
  1420.         break;
  1421.     }
  1422.     case DBG_DIVERT_SYSLOG:
  1423.         msg.data.syslogCmd = (Dbg_SyslogCmd)srcAddr;
  1424.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_SyslogCmd), 1);
  1425.         break;
  1426.     case DBG_BEGIN_CALL:
  1427.         SendRequest(sizeof(msg.opcode), 1);
  1428.         break;
  1429.     case DBG_END_CALL: {
  1430.         Boolean    moreData;
  1431.         do {
  1432.         SendRequest(sizeof(msg.opcode), 1);
  1433.         RecvReply(opcode, 0, NULL, &moreData, 1);
  1434.         } while (moreData);
  1435.         break;
  1436.     }
  1437.  
  1438.     case DBG_DETACH: {
  1439.         msg.opcode = (short) DBG_DIVERT_SYSLOG;
  1440.         msg.data.syslogCmd = DBG_SYSLOG_TO_ORIG;
  1441.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_SyslogCmd), 1);
  1442.  
  1443.         msg.opcode = (short) DBG_DETACH;
  1444.         msg.data.pc = *(int *) srcAddr;
  1445.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pc), 1);
  1446.         break;
  1447.     }
  1448.  
  1449.     case DBG_CONTINUE:
  1450.     case DBG_SINGLESTEP:
  1451.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pc), 1);
  1452.         currentVersion++;
  1453.         WaitForKernel();
  1454.         break;
  1455.  
  1456.     case DBG_CALL_FUNCTION: {
  1457.         int        returnValue;
  1458.  
  1459.         msg.data.callFunc.address = (int) destAddr;
  1460.         msg.data.callFunc.numBytes = numBytes;
  1461.         bcopy(srcAddr, msg.data.callFunc.buffer, numBytes);
  1462.         SendRequest(sizeof(msg.opcode) + 2 * sizeof(int) + numBytes, 1);
  1463.         RecvReply(opcode, sizeof(returnValue), &returnValue, NULL, 1);
  1464.         return (returnValue);
  1465.     }
  1466.     case DBG_REBOOT: {
  1467.         msg.data.reboot.stringLength = numBytes;
  1468.         bcopy(srcAddr, msg.data.reboot.string, numBytes);
  1469.         SendRequest(sizeof(msg.opcode) + sizeof(int) + numBytes, 1);
  1470.         return (0);
  1471.     }
  1472.     case DBG_GET_VERSION_STRING: {
  1473.         SendRequest(sizeof(msg.opcode), 1);
  1474.         RecvReply(opcode,numBytes , destAddr, NULL, 1);
  1475.         return (0);
  1476.     }
  1477.     default:
  1478.         printf("Unknown opcode %d\n", opcode);
  1479.         return(-1);
  1480.     }
  1481.     return(retVal);
  1482. }
  1483. remote_close()
  1484. {
  1485. }
  1486. remote_clean_up()
  1487. {
  1488.     MARK_DISCONNECTED;
  1489. }
  1490.  
  1491.  
  1492. read_kmem(memaddr, myaddr, len)
  1493.     char *memaddr;
  1494.     char *myaddr;
  1495.     int      len;
  1496. {
  1497.     static int fd = -1;
  1498.     int count;
  1499.  
  1500.     if (fd < 0) { 
  1501.     char template[100];
  1502.     /*
  1503.      * Open a temp file to write counters to. We unlink the file so it will
  1504.      * disappear when we exit.
  1505.      */
  1506.     strcpy(template, "/tmp/kgdbXXXXXXXX");
  1507.     fd = mkstemp(template);
  1508.     if (fd < 0) {
  1509.         error("open kmem tmp file");
  1510.     }
  1511.     (void) unlink(template);
  1512.     }
  1513.     if (lseek(fd, 0, L_SET) < 0) {
  1514.     error("lseek kmem file");
  1515.     }
  1516.     count = write(fd, memaddr, len);
  1517.     if (count != len) {
  1518.     return EIO;
  1519.     }
  1520.  
  1521.     /*
  1522.      * Rewind the file and read the counters from it.
  1523.      */
  1524.     count = lseek(fd, 0, L_SET);
  1525.     if (count >= 0) {
  1526.         count = read(fd, myaddr, len);
  1527.     }
  1528.     if (count != len) {
  1529.     return EIO;
  1530.     }
  1531.     return 0;
  1532. }
  1533.  
  1534.  
  1535.